// pages/home/home.js
import {situationApi, queryOneApi} from '../../api/home'
import tools from '../../tools/tools';
// import { initChart } from './initEchart2'; // 引入封装的图表函数
import store from '../../utils/store';
const targetConfig = [
    { indicatorName: "体重", unit: "kg" },
    { indicatorName: "骨骼肌率", unit: "%" },
    { indicatorName: "体脂率", unit: "%" },
    { indicatorName: "肌肉率", unit: "%" }
  ]
Page({
  /**
   * 页面的初始数据
   */
  data: {
    name: '',
    list: [],
    // ec: {
    //   onInit: initChart
    // },
    products: [{
        id: 1,
        name: '商品1',
        price: 99,
        image: 'https://picsum.photos/200/300',
        stock: 150,
        sales: 950,
        score: 4.4,
        tags: []
      },
      {
        id: 2,
        name: '商品2',
        price: 199,
        image: 'https://picsum.photos/200/300',
        stock: 150,
        sales: 950,
        score: 4.4,
        tags: []
      },
      {
        id: 3,
        name: '商品3',
        price: 299,
        image: 'https://picsum.photos/200/300',
        stock: 150,
        sales: 950,
        score: 4.4,
        tags: []
      },
      {
        id: 4,
        name: '商品4',
        price: 399,
        image: 'https://picsum.photos/200/300',
        stock: 150,
        sales: 950,
        score: 4.4,
        tags: []
      },
      {
        id: 5,
        name: '商品4',
        price: 399,
        image: 'https://picsum.photos/200/300',
        stock: 150,
        sales: 950,
        score: 4.4,
        tags: []
      }
    ],
    // 购物车数据
    cart: [],
    // 购物车数量
    cartCount: 0,
    // 动画元素位置
    animationData: {},
    // 是否显示动画元素
    showAnimation: false,
    tableData: [],
    today: tools.formatDate(new Date())
  },
  onShow() {
    // 基础数据
    this.getBaseData(store.state.studentId);
    // 训练数据
    this.getTrainData()
  },
  // 获取基本信息
  async getBaseData(supervisorId) {
    try {
      // 1. 检查参数合法性（前置校验，避免无效请求）
      if (typeof supervisorId === 'undefined' || supervisorId === null) {
        throw new Error('缺少必要参数：supervisorId');
      }
    
      // 2. 接口请求（捕获网络错误、接口异常）
      const situationRes = await situationApi({ supervisorId });
      // 校验接口返回格式是否正常
      if (!situationRes || !situationRes.data || !Array.isArray(situationRes.data)) {
        throw new Error('接口返回数据格式异常，预期为数组');
      }
      const baseData = situationRes.data;
    
      // 3. 校验 targetConfig 是否存在（避免 map 调用报错）
      if (!Array.isArray(targetConfig)) {
        throw new Error('targetConfig 格式错误，预期为数组');
      }
      console.log(targetConfig, 'targetConfig')
      // 4. 处理数据转换（避免 find 结果为 undefined 导致的问题）
      const resultData = targetConfig.map((config, index) => {
        // 校验 config 结构是否合法
        if (!config || typeof config !== 'object' || !config.indicatorName) {
          console.warn(`targetConfig 第 ${index} 项结构异常，已跳过`);
          return { title: '未知指标', num: '0', unit: '' }; // 兜底处理
        }
        console.log(baseData, 'baseData')
        const rawItem = baseData[0].details.find(item => item?.indicatorName === config.indicatorName);
        return {
          title: config.indicatorName,
          num: rawItem ? String(rawItem.value ?? '0') : '0', // 处理 rawItem.value 为 undefined/null 的情况
          unit: config.unit || '' // 单位默认空字符串
        };
      });
    
      // 5. 设置数据（避免 baseData[0] 不存在导致的报错）
      this.setData({
        name: baseData.length > 0 ? baseData[0].name || '未知名称' : '未知名称', // 处理 baseData 为空或 name 不存在
        list: resultData // 本身已处理空数组情况，无需再 || []
      });
    
    } catch (err) {
      // 统一错误处理：区分错误类型，给出明确提示
      const errorMsg = err instanceof Error ? err.message : '未知错误';
      console.error('数据处理失败：', errorMsg, err); // 详细日志便于排查
    
      // 1. 前端友好提示（根据场景选择 Toast/Alert）
      wx.showToast({
        title: '数据加载失败',
        icon: 'none',
        duration: 2000
      });
    
      // 2. 数据兜底（避免页面空白）
      this.setData({
        name: '',
        list: []
      });
    
    } finally {
      // 3. 无论成功失败，都执行的操作（如关闭加载中状态）
      this.setData({
        loading: false // 假设页面有加载状态，此处关闭
      });
    }
  },
  // 训练记录
  async getTrainData() {
    try {
      // 1. 前置校验：检查依赖参数是否存在
      if (!store.state.coachId || !store.state.mac) {
        throw new Error('缺少必要参数：coachId 或 mac');
      }
      // 2. 调用接口并捕获请求异常
      const queryOneRes = await queryOneApi({
        coachId: store.state.coachId,
        factoryNo: store.state.mac,
        pageNum: 1,
        pageSize: 5
      });
      // 3. 校验接口返回格式（防止接口返回 null/undefined 或非对象）
      if (!queryOneRes || typeof queryOneRes !== 'object') {
        throw new Error('接口返回格式异常，预期为对象');
      }
      // 4. 校验 data 字段是否为数组（避免 map 调用报错）
      const rawData = queryOneRes.data;
      if (!Array.isArray(rawData)) {
        throw new Error('接口返回 data 不是数组，无法处理');
      }
      // 5. 处理数据转换（对每个 item 做容错，避免 calorie 格式错误）
      const tableData = rawData.map((item, index) => {
        // 确保 item 是对象（防止非对象元素导致的报错）
        if (!item || typeof item !== 'object') {
          console.warn(`第 ${index} 条数据格式异常，已跳过`);
          return { calorie: 0 }; // 兜底默认值
        }
        // 安全转换 calorie 为整数（处理 null/undefined/非数字的情况）
        let calorie = 0;
        if (item.calorie !== null && item.calorie !== undefined) {
          const parsed = Number.parseInt(item.calorie, 10);
          calorie = isNaN(parsed) ? 0 : parsed; // 转换失败则用 0
        }
        // if (item.anaerobic == 0) {
        //   item.anaerobic = 
        // }
        // 返回处理后的完整数据（保留其他字段）
        return { ...item, calorie };
      });
  
      // 6. 安全设置数据
      this.setData({ tableData });
      console.log('表格数据加载成功');
  
    } catch (err) {
      // 统一错误处理：日志 + 兜底数据 + 用户提示
      const errorMsg = err instanceof Error ? err.message : '未知错误';
      console.error('表格数据加载失败：', errorMsg, err);
  
      // 设置兜底数据，避免页面空白或错乱
      this.setData({ tableData: [] });
  
      // 提示用户（根据场景选择 Toast 或其他方式）
      wx.showToast({
        title: '数据加载失败',
        icon: 'none',
        duration: 2000
      });
    }
  },
  // 商品列表页面
  goGoodDetail() {
    if (app.checkLogin()) {
      wx.navigateTo({
        url: '/homePage/goods/goods',
      })
    }
  },
  // 初始化购物车
  initCart: function () {
    const cart = wx.getStorageSync('cart') || [];
    const cartCount = cart.reduce((total, item) => total + item.quantity, 0);
    this.setData({
      cart,
      cartCount
    });
  },
  // 添加到购物车
  addToCart: function (e) {
    const productId = e.currentTarget.dataset.id;
    const productIndex = e.currentTarget.dataset.index;

    // 获取商品信息
    const product = this.data.products[productIndex];

    // 开始添加购物车动画
    this.startAddToCartAnimation(e, product);

    // 更新购物车数据
    this.updateCart(productId);
  },

  // 开始添加购物车动画
  startAddToCartAnimation: function (e, product) {
    let index = e.currentTarget.dataset.index
    const that = this;
    const query = wx.createSelectorQuery();
    // 获取添加按钮位置
    query.select(`.add-to-cart-btn${index}`).boundingClientRect()
    // 获取购物车图标位置
    query.select('.cart-icon').boundingClientRect();
    // 获取窗口信息
    query.selectViewport().scrollOffset();

    query.exec(function (res) {
      // 按钮位置
      const btnRect = res[0];
      // 购物车位置
      const cartRect = res[1];
      // 滚动距离
      const scrollTop = res[2].scrollTop;
      // 创建动画
      const animation = wx.createAnimation({
        duration: 800,
        timingFunction: 'cubic-bezier(0.2, 0.8, 0.2, 1)',
      });

      // 设置动画起始位置
      that.setData({
        showAnimation: true,
        animationImage: product.image,
        cartTop: btnRect.top + 'px',
        cartLeft: btnRect.left + 'px'
      });

      // 强制刷新
      setTimeout(() => {
        // 设置动画路径
        animation.translate(
          cartRect.left - btnRect.left - 8,
          cartRect.top - btnRect.top - 6
        ).scale(0.3, 0.3).opacity(0.5).step();

        that.setData({
          animationData: animation.export()
        });

        // 动画结束后重置
        setTimeout(() => {
          that.setData({
            showAnimation: false,
            animationData: {}
          });

          // 购物车图标抖动动画
          that.shakeCartIcon();

          // 显示添加成功提示
          wx.showToast({
            title: '已添加到购物车',
            icon: 'success',
            duration: 1500
          });
        }, 800);
      }, 10);
    })
  },
  // 购物车图标抖动动画
  shakeCartIcon: function () {
    const animation = wx.createAnimation({
      duration: 500,
      timingFunction: 'ease',
    });

    animation.scale(1.2, 1.2).step();
    animation.scale(0.8, 0.8).step();
    animation.scale(1.0, 1.0).step();

    this.setData({
      cartIconAnimation: animation.export()
    });

    setTimeout(() => {
      this.setData({
        cartIconAnimation: {}
      });
    }, 500);
  },
  // 更新购物车数据
  updateCart: function (productId) {
    let cart = this.data.cart;
    const productIndex = cart.findIndex(item => item.id === productId);

    if (productIndex !== -1) {
      // 商品已在购物车中，增加数量
      cart[productIndex].quantity += 1;
    } else {
      // 商品不在购物车中，添加到购物车
      const product = this.data.products.find(item => item.id === productId);
      cart.push({
        id: product.id,
        name: product.name,
        price: product.price,
        image: product.image,
        stock: product.stock,
        quantity: 1,
        selected: true
      });
    }
    const cartCount = cart.reduce((total, item) => {
      console.log(total, item.quantity)
      return total + item.quantity
    }, 0);
    console.log("cartCount", cartCount)
    // 更新数据
    this.setData({
      cart,
      cartCount
    });
    console.log("cart", cart)
    // 保存到本地存储
    wx.setStorageSync('cart', cart);
  },
  // 跳转到购物车页面
  goToCart: function () {
    wx.navigateTo({
      url: '/pages/carts/carts'
    });
  },
  goUser() {
    wx.switchTab({
      url: '/pages/my/my'
    })
  }
})
